Amiga Collections: Taifun/Taifun 102 (1989-08-15)(Ossowski, Stefan)(DE)(PD).zip/Taifun 102 (1989-08-15)(Ossowski, Stefan)(DE)(PD).adf/Life_Research/doc

Text File | 1989-04-21 | 11KB | 319 lines

 Program : Life in Line
 Version : 1.3
 Author  : Rainer Umbach

 Address : Rainer Umbach    Rainer Umbach     WOLFEN
           Schulweg 6       Rosenbachweg 6    MailBox PELA
           3501 Espenau 2   3400 Goettingen   Tel.: Germany/0561/51880
           West-Germany     West-Germany      Par.: 1200/300/n/8
                                              (there`s a special guest file
                                               to leave a message)

+-------------------------------------------------------------------------+
|                Life in Line Research Program Release 1.3                |
+-------------------------------------------------------------------------+


Contents of this documentation:

  1) General information about Life in Line

  2) Hints for using this program

  3) General spoken

****************************************************************************

1) General information about Life in Line

  Everyone is familiar with the Game of Life by John Horten Convway or has at
least seen it already on a list of public-domain programs. It is
a model for cellular automata.
  One can play the Game of Life in various dimensions: Life in Line
simulates a single dimensional cellular automata: a linear automata. A
single generation of a linear automata consists of only one line of cells;
but following generations are layed out one after another (space-time-
diagram).
  The next condition of a certain cell depends on the condition of
neighboring cells as well as the condition of the original cell. There are
two important points:

  1) Number of possible conditions: 2

     (dead or alive)

  2) Number of neighboring cells: 2 or 3

     This number restores the number of neighboring cells on each side and
     is called RAD in the program.

       RAD=2                                              RAD=3

         |                  original cells                  |
     o o o o o                                        o o o o o o o
     \ /   \ /                                        \ | /   \ | /
      2     2             neighboring cells             3       3

     RAD=2 uses five cells to determine the next condition; RAD=3
     uses seven.

  Now the living cells are counted. The amount will be between two certain
values:

  1) With Rad=2 the amount will be between zero and five.

  2) With RAD=3 the amount will be between zero and seven.

  Now it must be decided what should happened to each cell.

              Amount of cells      5 | 4 | 3 | 2 | 1 | 0
              -----------------   ---+---+---+---+---+---
              Next condition       0 | 1 | 0 | 1 | 0 | 0

If you use the lower half of the chart as binary digits it would be RULE
20. Therefore, there are 64 rules for RAD=2 (RGL 0-63) and 255 for RAD=3
(RGL 0-255).
  Now one applies these rules to random patterns or proceeds systematically.
The starting pattern consists of zeros and ones. Therefore, one can convert
this pattern into a decimal number, which is called MST.
  With Life in Line one can now systematically apply several RGL to
various patterns and be pleased with the results, or have deeper
philosophical ideas.

****************************************************************************

2) Hints for using this program

  You have already seen the main menu, right? Here it is again:

  **  DISPLAY = 0, CALCULATION = 1, DOC = 2, Stop = 3 **

  0) This is the normal display-mode.

  1) This mode only calculates without displaying.

  2) This documentation.

  3) Guess!

  If you have chosen 0) or 1), you must now enter the two values for RAD and
RGL. If you want to keep the old value, simply push RETURN. From now on
`zero` stands for `no` and `one` stands for `yes`

  CALCULATION-Mode
  ----------------

  For certain values for RAD and RGL the following questions will appear on
the screen that you must answer.

  ** recognize pattern to economize output (0 or 1) **

  If you have entered `1` it continues with:

  ** check pattern at generation # **

  The fact of the matter is this: In order to shorten the calculation time,
familiar patterns are filtered out and are not regarded as `solutions`. With
the second input you can determine which of the patterns` generations will be
checked.

  It continues with:

  ** break off calculation at generation # **

  Here you enter the generation at which the calculation should break off
When there are still living cells at this generation, the original pattern
is regarded as a `solution`. The calculation is automatically broken off
when there are no more living cells.

  Afterwards follows:

  ** check even pattern too (0 or 1) **

  A range of numbers is tested by the calculation. The original patterns that
last a long time will be regarded as `solutions`.There are only two types of
original patterns: odd and even. For example:

  MST 229 --> binary 11100101
  MST 230 --> binary 11100110

  At this point only the pattern, the combination of digits, is important.
Only the living cells are important because the pattern is copied onto a
`dead` field, that is, a field made up of zeros. Therefore, with MST 230 only
the following pattern is considered: 1110011.

  binary 1110011 --> MST 115

  Therefore, every binary pattern of a even number is already calculated
with an odd number.If you have already explored the range from zero to
your starting pattern, you should enter zero, and if not, you should
enter `1`.

  Now you can finally enter your starting pattern:

  ** first MST: **

 All the (odd) patterns will be calculated through, one at a time, from the
number you have entered to MST+10000. During the calculation, you have the
followiung choices:

  ** save solutions    : s **
  ** display solutions : d **
  ** restart program   : r **

  If you enter `s` the solutions up to this point are copied into the
`MST.dat` file, that can be loaded from the DISPLAY-mode. If you push `d`,
the computer jumps to this mode and displays the solutions (long lasting
patterns). `r` brings you back to the main-menu.
  The actual pattern and the number of the solutions will always be shown:

  ** MST: xyxzyx **
  ** solutions: ab **

  DISPLAY-Mode
  ------------

  At this point it is now possible to load various data files: the
`MST.dat` file from the CALCULATION mode or a `presentation` file.
A `presentation` file contains various MST as well as a remark on each.
There are several such `presentation` files on this disk, that can be
created with the CLI command `ed`. Please note the `example_file`.
In the program it look like this:

  ** if exists load MST.dat file      (0 or 1): **
  ** if exists load presentation file (0 or 1): **

  At this time there are `presentation` files for the following values of
RAD and RGL:

                  RAD  |   RGL  |  file name
                -------+--------+-------------
                   2   |    20  |    2.20
                   2   |    52  |    2.52
                   3   |    52  |    3.52
                   3   |    72  |    3.72
                   3   |    88  |    3.88
                   3   |   152  |    3.152

  If you have entered zero twice, the following menu will appear:

  (1) ** restart program : *               **
  (2) ** binary input    : ,abc            **
  (3) ** decimal input   : xyz             **
  (4) ** mutation mode   : xyz#            **
  (5) ** magnify mode    : ,abc. or  xyz.  **
  (6) ** casual pattern  : <wide>          **
  (7) ** printer mode on : p               **
  (8) ** short Input on  : xyz+            **
  (9) ** MST:                              **

  The program now expects an input. Please use only the forms from the
menu.

  The following remarks correspond to points (1) through (8).

  (1):  Return to main menu

  (2):  Enter MST as a binary number. Example: ,110011001111.

  (3):  Enter MST as a decimal number. Example: 14568.

  (4):  The `biotope` consists of a field of 600 cells. When the
           mutation mode is used, a random cell is brought to life.
           This causes an otherwise continuous pattern to mutate.
           Example: 635#.

  (5):  At this point the single cells are enlarged and displayed on the
           screen.
           Example: ,1101011. or 139893..

  (6):  Cells from the biotope are randomly brought to life. The maximum
           number of cells is given with `wide` and is between 0 and 500.
           Example: <350>.

  (7):  If there is a printer available you have got the opportunity to
           print those patterns the program calculates. There are no errors
           while using the BASIC version, I hope so. Actually I use a
           STAR LC-10 printer that runs with an EPSON LX-800 emulation.
           The program uses the PAR: device.
           Typing `p` you get:

           ** printer mode off: p               **

           Note: If you see `off` the option is on, and if you see `on`
                 the option is off.

  (8):  This menu point makes it easier to enter large numbers if they have
           the folling form:

                                     xyzsrtd
                                     xyzjkfw
                                  xyznmbsdsd
                                       xyzee

           Enter the first 3 digits of the first number followed by `+`
           (Example: xyz+). Now the menu is a little different.

           ** short Input off : -             **
           ** MST: xyz+                       **
           ** MST:                            **

           If you enter the rest of the respective number, the digits xyz
           will be placed automatically in front of this number.

           a) without point 7
                                  9345732 (RETURN)
                                  9345884 (RETURN)
                                   934539 (RETURN)
           b) with point 7
                                  9345+   (RETURN)
                                  732     (RETURN)
                                  884     (RETURN)
                                  39      (RETURN)

           By entering `-` you will leave this input mode.

  (9):  Your pattern input.

****************************************************************************

3) General spoken

   As you already know this program is public domain software. You are
allowed to copy LIFE IN LINE as often as you want to. I would, however,
like to see your results. That means I want to know your patterns (of course
with RAD and RGL) or your opinion about Life etc. I try to answer every
letter that I receive.
   Otherwise, if you are writing, or have written programs concerning the
GAME OF LIFE, please contact me, because I am really interested in other
versions. Please also try to contact me if you read Dewdney`s
`Computer Recreations` in Scientific American and try to hack those problems
on your computer.

****************************************************************************

Text: Rainer Umbach and Michele Bynum.